package com.zxy.health.utils;

/*
 * Copyright (C), 2012-2020, com.net
 * FileName: StringUtils.java
 * Author:   wangkai
 * Date:     2012-05-01
 * Description: //模块目的、功能描述
 * History: //修改记录
 * <author>      <time>      <version>    <desc>
 * 修改人姓名             修改时间            版本号                  描述
 */


import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.UUID;
import java.util.regex.Pattern;



public class StringUtils {

    public static Map<String, Integer> hexMap = new HashMap<String, Integer>();
    public static Map<String, Integer> byteMap = new HashMap<String, Integer>();

    static {
        hexMap.put("0", 2);
        hexMap.put("1", 2);
        hexMap.put("2", 2);
        hexMap.put("3", 2);
        hexMap.put("4", 2);
        hexMap.put("5", 2);
        hexMap.put("6", 2);
        hexMap.put("7", 2);
        hexMap.put("c", 4);
        hexMap.put("d", 4);
        hexMap.put("e", 6);
        hexMap.put("f", 8);

        byteMap.put("0", 1);
        byteMap.put("1", 1);
        byteMap.put("2", 1);
        byteMap.put("3", 1);
        byteMap.put("4", 1);
        byteMap.put("5", 1);
        byteMap.put("6", 1);
        byteMap.put("7", 1);
        byteMap.put("c", 2);
        byteMap.put("d", 2);
        byteMap.put("e", 3);
        byteMap.put("f", 4);
    }

    /**
     * 判断字符串是否为空
     *
     * @param str
     *            如果字符串为null,"null"或者为空，都将返回true，否则返回false
     * @return
     */
    public static boolean isEmpty(String str) {
        if (str == null || "".equals(str.trim()) || "null".equalsIgnoreCase(str.trim())) {
            return true;
        }
        return false;
    }

    /**
     * 清洗字符串
     *
     * @param str
     *            待清晰的字符串
     * @param defaultValue
     *            默认替换值
     * @return
     */
    public static String clear(String str, String defaultValue) {
        if (isEmpty(str)) {
            return defaultValue;
        } else {
            return str.trim();
        }
    }

    /**
     * 判断端口号是否正确
     *
     * @param port
     * @return
     */
    public static boolean isPort(String port) {
        if (isEmpty(port)) {
            return false;
        }
        try {
            Integer i = Integer.parseInt(port);
            if (i >= 0 && i <= 65535) {
                return true;
            }
            return false;// 不在端口范围
        } catch (Exception e) {
            // 非数字串
            return false;
        }
    }

    /**
     * 判断字符串是否可转换为Long类型
     *
     * @param longStr
     * @return
     */
    public static boolean isLong(String longStr) {
        if (isEmpty(longStr)) {
            return false;
        }
        try {
            Long.parseLong(longStr);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断字符串是否可转换为Integer类型
     *
     * @param intStr
     * @return
     */
    public static boolean isInteger(String intStr) {
        if (isEmpty(intStr)) {
            return false;
        }
        try {
            Integer.parseInt(intStr);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     *
     * 判断字符串是否可转换为float类型 <br>
     * @param floatStr
     * @return
     */
    public static boolean isFloat(String floatStr) {
        if (isEmpty(floatStr)) {
            return false;
        }
        try {
            Float.parseFloat(floatStr);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 获取浮点数小数位数
     *
     * @param f
     * @return
     */
    public static int getFloatScale(float f) {
        String s = String.valueOf(f);
        String[] temp = s.split("\\.");
        if (temp.length == 2) {
            return temp[1].length();
        }
        return 0;
    }

    /**
     *
     * 判断字符串是否可转换为Double类型 <br>
     * @param doubleStr
     * @return
     */
    public static boolean isDouble(String doubleStr) {
        if (isEmpty(doubleStr)) {
            return false;
        }
        try {
            Double.parseDouble(doubleStr);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     *
     * 判断字符串是否可转换为日期类型 <br>
     *
     * @param dateStr
     * @return
     */
    public static boolean isDate(String dateStr) {
        if (isEmpty(dateStr)) {
            return false;
        }
        try {
            DateUtils.parse(dateStr, DateUtils.yyyy_MM_dd);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     *
     * 判断字符串是否可转换为日期时间类型 <br>
     *
     * @param dateTimeStr
     * @return
     */
    public static boolean isDateTime(String dateTimeStr) {
        if (isEmpty(dateTimeStr)) {
            return false;
        }
        try {
            DateUtils.parse(dateTimeStr, DateUtils.yyyy_MM_dd_HH_mm_ss);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     *
     * 判断字符串是否可转换为日期时间类型 <br>
     *
     * @param dateTimeStr
     * @param formatterStr
     *            日期时间格式化串
     * @return
     */
    public static boolean isDateTime(String dateTimeStr, String formatterStr) {
        if (isEmpty(dateTimeStr)) {
            return false;
        }
        try {
            DateUtils.parse(dateTimeStr, formatterStr);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 判断字符串是否可转换为BigDecimal类型
     *
     * @param decimalStr
     * @return
     */
    public static boolean isDecimal(String decimalStr) {
        try {
            new BigDecimal(decimalStr);
            return true;
        } catch (NumberFormatException e) {
            return false;
        }
    }

    /**
     * 将数值型字符串转换为数字
     *
     * @param intStr
     * @return
     */
    public static int intValue(String intStr) {
        return Integer.parseInt(intStr);
    }

    public static int intValue(String intStr, int defaultValue) {
        if (StringUtils.isInteger(intStr)) {
            return intValue(intStr);
        } else {
            return defaultValue;
        }
    }

    /**
     * 将长整形字符串转换为长整形数值
     *
     * @param longStr
     * @return
     */
    public static long longValue(String longStr) {
        return Long.parseLong(longStr);
    }

    /**
     *
     * 将float类型字符串转换为float类型 <br>
     *
     * @param floatStr
     * @return
     */
    public static Float floatValue(String floatStr) {
        return Float.parseFloat(floatStr);
    }

    /**
     *
     * 将Double类型字符串转换为Double类型 <br>
     *
     * @param doubleStr
     * @return
     */
    public static Double doubleValue(String doubleStr) {
        return Double.parseDouble(doubleStr);
    }

    /**
     * 将数值型字符串转换为数值型
     *
     * @param decimalStr
     * @return
     */
    public static BigDecimal decimalValue(String decimalStr) {
        return new BigDecimal(decimalStr);
    }

    /**
     * 用于解决URL参数中文奇数乱码问题
     *
     * @param s
     * @return
     */
    public static String encodeURL(String s) {
        if (StringUtils.isNotEmpty(s)) {
            try {
                return URLEncoder.encode(s, "UTF-8");
            } catch (UnsupportedEncodingException e) {
            }
        }
        return s;
    }

    /**
     * 判断给定的字符串是否可以用作包名
     *
     * @return
     */
    public static boolean isPackageNameCorrect(String pkgName) {
        boolean isCorrect = true;

        if (isEmpty(pkgName)) {
            return true;
        }

        pkgName = pkgName.trim().toLowerCase();// 去除两端空格，并转换为小写格式

        // 包命名规则：可以取以下字符，且只能以字母或下划线开始，用"."分隔包名，且最后一个字符不能为"."
        String criterionStr1 = "abcdefghijklmnopqrstuvwxyz_";
        String criterionStr2 = "0123456789.";

        char[] chars = pkgName.toCharArray();
        for (char c : chars) {
            if (!criterionStr1.contains(String.valueOf(c)) && !criterionStr2.contains(String.valueOf(c))) {
                return false;
            }
        }

        // 判断首字符
        char c = pkgName.charAt(0);
        if (!criterionStr1.contains(String.valueOf(c))) {
            return false;
        }

        // 判断尾字符
        if (pkgName.endsWith(".")) {
            return false;
        }

        return isCorrect;
    }

    /**
     * 判断字符是否是中文
     *
     * @param c
     *            字符
     * @return
     */
    public static boolean isChinese(char c) {
        // 假定英文范围为0-127(ASCII),128-255(ASCII扩展)
        int enEnd = 255;
        int code = c;
        return code > enEnd;
    }

    /**
     * 判断是否是ASCII码 <br>
     *
     * @param c  字符
     * @return
     */
    public static boolean isAscii(char c) {
        // ASCII码:0-127(每个字符占1字节)
        int begin = 0;
        int end = 127;
        int code = c;
        return code >= begin && code <= end;
    }

    /**
     * 判断是否是ASCII扩展码 <br>
     * 〈功能详细描述〉
     *
     * @param c  字符
     * @return
     */
    public static boolean isAsciiExtend(char c) {
        // ASCII扩展码:128-255(每个字符占2字节)
        int begin = 128;
        int end = 255;
        int code = c;
        return code >= begin && code <= end;
    }

    /**
     * 截取字符串
     *
     * @param str 待截取的字符串
     * @param len 截取长度(2个英文字符相当于一个中文字符)
     * @return
     */
    public static String cutString(String str, int len) {

        if (StringUtils.isEmpty(str)) {
            return "";
        }

        if (len <= 0 || len * 2 >= length(str)) {
            return str;// 字符长度未达到截断限制要求
        }

        int totalLength = 0;
        StringBuilder result = new StringBuilder();

        char[] chars = str.toCharArray();
        for (char c : chars) {
            if (totalLength < len * 2) {
                if (isChinese(c)) {
                    if (totalLength + 2 <= len * 2) {
                        result.append(c);
                        totalLength += 2;
                    } else {
                        break;
                    }
                } else {
                    if (totalLength + 1 <= len * 2) {
                        result.append(c);
                        totalLength++;
                    } else {
                        break;
                    }
                }
            } else {
                break;
            }
        }
        result.append("...");
        return result.toString();
    }

    /**
     * 计算字符串长度(一个中文字符长度为2)
     *
     * @param str
     *            待计算的字符串
     * @return
     */
    public static int length(String str) {
        return length(str, 2);
    }

    /**
     *
     * 计算字符串长度 <br>
     * 〈功能详细描述〉
     *
     * @param str
     *            字符段
     * @param size
     *            一个中文算作的长度
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public static int length(String str, int size) {
        int totalLength = 0;
        char[] chars = str.toCharArray();
        for (char c : chars) {
            if (isAsciiExtend(c)) {
                totalLength += 2;
            } else if (isChinese(c)) {
                totalLength += size;
            } else {
                totalLength++;
            }
        }
        return totalLength;
    }

    /**
     * 去除字符串中的HTML元素
     *
     * @param str 待处理的字符串
     * @return
     */
    public static String removeHtmlTag(String str) {
        String htmlStr = str; // 含html标签的字符串
        String textStr = "";
        Pattern p_script;
        java.util.regex.Matcher m_script;
        Pattern p_html;
        java.util.regex.Matcher m_html;
        try {
            String regEx_html = "<[^>]+>"; // 定义HTML标签的正则表达式
            String regEx_script = "<[/s]*?script[^>]*?>[/s/S]*?<[/s]*?//[/s]*?script[/s]*?>"; // 定义script的正则表达式{或<script[^>]*?>[/s/S]*?<//script>

            p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);
            m_script = p_script.matcher(htmlStr);
            htmlStr = m_script.replaceAll(""); // 过滤script标签

            p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
            m_html = p_html.matcher(htmlStr);
            htmlStr = m_html.replaceAll(""); // 过滤html标签

            textStr = htmlStr;
        } catch (Exception e) {
            System.err.println("Html2Text: " + e.getMessage());
        } finally {
            p_script = null;
            m_script = null;
            p_html = null;
            m_html = null;
        }
        return textStr;// 返回文本字符串
    }

    /**
     * 多个对象字符串相加
     *
     * @param objs 对象数组
     * @return
     */
    public static String concat(Object... objs) {
        StringBuilder str = new StringBuilder();
        for (Object obj : objs) {
            str.append(obj.toString());
        }
        return str.toString();
    }

    /**
     *
     * 编码，类似javascript中的escape功能 <br>
     *
     * @param src
     * @return
     */
    public static String escape(String src) {
        int i;
        char j;
        StringBuffer tmp = new StringBuffer();
        tmp.ensureCapacity(src.length() * 6);
        for (i = 0; i < src.length(); i++) {
            j = src.charAt(i);
            if (Character.isDigit(j) || Character.isLowerCase(j) || Character.isUpperCase(j))
                tmp.append(j);
            else if (j < 256) {
                tmp.append("%");
                if (j < 16)
                    tmp.append("0");
                tmp.append(Integer.toString(j, 16));
            } else {
                tmp.append("%u");
                tmp.append(Integer.toString(j, 16));
            }
        }
        return tmp.toString();
    }

    /**
     *
     * 解码，类似javascript中的unescape功能 <br>
     *
     * @param src
     * @return
     */
    public static String unescape(String src) {
        StringBuffer tmp = new StringBuffer();
        tmp.ensureCapacity(src.length());
        int lastPos = 0, pos = 0;
        char ch;
        while (lastPos < src.length()) {
            pos = src.indexOf("%", lastPos);
            if (pos == lastPos) {
                if (src.charAt(pos + 1) == 'u') {
                    ch = (char) Integer.parseInt(src.substring(pos + 2, pos + 6), 16);
                    tmp.append(ch);
                    lastPos = pos + 6;
                } else {
                    ch = (char) Integer.parseInt(src.substring(pos + 1, pos + 3), 16);
                    tmp.append(ch);
                    lastPos = pos + 3;
                }
            } else {
                if (pos == -1) {
                    tmp.append(src.substring(lastPos));
                    lastPos = src.length();
                } else {
                    tmp.append(src.substring(lastPos, pos));
                    lastPos = pos;
                }
            }
        }
        return tmp.toString();
    }

    /**
     *
     * 获取UUID: <br>
     *
     * @return
     */
    public static String getUUID() {
        return UUID.randomUUID().toString();
    }
    /**
     * 获取32位宽度的UUID(大写字母)
     * @return
     */
    public static String getSimpleUUID() {
        return getUUID().replace("-", "").toUpperCase();
    }

    /**
     * 随机生成指定长度的字符串
     *
     * @param len
     *            生成的字符串长度
     * @return
     */
    public static String genRandomStr(int len) {
        int i; // 生成的随机数，用作数组索引，取随机字符串
        int count = 0; // 生成的密码的长度
        char[] str = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
                't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };

        StringBuffer pwd = new StringBuffer("");
        Random r = new Random();
        while (count < len) {
            // 生成随机数，取绝对值，防止生成负数，
            i = Math.abs(r.nextInt(str.length)); // 生成的数最大为36-1
            if (i >= 0 && i < str.length) {
                pwd.append(str[i]);
                count++;
            }
        }
        return pwd.toString();
    }

    /**
     *
     * 判断字符串是否符合电子邮件格式 <br>
     *
     * @param email 电子邮件
     * @return
     */
    public static boolean isEmail(String email) {
        if (StringUtils.isEmpty(email)) {
            return false;
        }

        if (!email.matches("^[a-zA-Z]{1}([a-zA-Z0-9]|[-_])*@[a-zA-Z0-9]+.[a-zA-z]+")) {
            return false;
        }
        return true;
    }

    /**
     *
     * 判断字符串是否符合电子邮件前缀格式 <br>
     *
     * @param emailPrefix
     *            电子邮件前缀
     * @return
     */
    public static boolean isEmailPrefix(String emailPrefix) {
        // 正则语法[字母开头，包含字母，数字，下划线和中划线-_]
        if (!emailPrefix.matches("^[a-zA-Z]{1}([a-zA-Z0-9]|[-_])*")) {
            return false;
        }

        return true;
    }

    /**
     * 数据左补齐
     *
     * @param str 待补齐文本
     * @param flag 补齐用的字符
     * @param length 补齐后的长度
     * @return
     */
    public static String leftCompleting(String str, char flag, int length) {
        StringBuilder sb = new StringBuilder();
        if (isEmpty(str)) {
            return null;
        }

        if (str.length() >= length) {
            return str;
        }

        int n = length - str.length();
        for (int i = 0; i < n; i++) {
            sb.append(flag);
        }
        sb.append(str);
        return sb.toString();
    }

    /**
     * 身份证格式判断
     *
     * @param id_card  身份证号码
     * @return
     */
    public static boolean isIdCard(String id_card) {
        // 1.判断是不是18位号码
        if (id_card.length() != 18) {
            return false;
        }
        int[] Wi = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };// 加权因子
        char[] card = id_card.toCharArray();// ToCharArray(0, idCard.Length -
        // 1);
        int[] Ai = new int[card.length - 1];
        // 2.将前17位转换成数字
        for (int i = 0; i < card.length - 1; i++) {
            Ai[i] = Integer.parseInt(card[i] + "");
        }
        // 3.加权总和
        int sum = sumNum(Ai, Wi);
        // 4.校验码
        char vcode = mod(sum);
        // 5.校验码和身份证最后一位比较，是否相同
        return vcode == card[17];
    }

    /**
     * 十七位数字本体码加权求和
     *
     * @param Ai
     * @param Wi
     * @return
     */
    private static int sumNum(int[] Ai, int[] Wi) {
        int sum = 0;
        for (int i = 0; i < Ai.length; i++) {
            sum += Ai[i] * Wi[i];
        }
        return sum;
    }

    /**
     * 计算模
     *
     * @param s
     * @return
     */
    private static char mod(int s) {
        int temp = s % 11;
        char[] vcode = { '1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2' };
        return vcode[temp];
    }

    /**
     * 判断字符串是否符合手机号格式
     *
     * @param mobile
     * @return
     */
    public static boolean isMobile(String mobile) {
        if (isEmpty(mobile)) {
            return false;
        }

        // 手机号正则表达式:^[1-9]{1}[0-9]{10}$
        if (!mobile.matches("^[1-9]{1}[0-9]{10}$")) {
            return false;
        }

        return true;
    }

    /**
     * 处理手机号
     *
     * @param mobile
     *            手机号
     * @return 180****1111
     */
    public static String dealMobile(String mobile) {
        if (!isMobile(mobile)) {
            return "";
        }

        return mobile.substring(0, 3) + "****" + mobile.substring(7);
    }

    /**
     * 获取随机8位整数
     *
     * @return
     */
    public static int getRamdomNum8Bits() {
        return (int) (89999999 * Math.random()) + 10000000;
    }

    /**
     * 返回字符串各字符16进制编码
     *
     * @param s
     *            待编码字符
     * @return
     */
    public static String toHexString(String s) {
        if (s == null || "".equals(s.trim())) {
            return "";
        }

        StringBuilder sb = new StringBuilder();
        char[] array = s.toCharArray();
        for (char c : array) {
            sb.append(Integer.toHexString((int) c));
        }
        return sb.toString();
    }

    /**
     * 判断文本是否含有emoji表情
     *
     * @param s
     * @return
     */
    public static boolean hasEmoji(String s) {
        if (isEmpty(s)) {
            return false;
        }
        return contains4BytesChar(s);
    }

    /**
     * 字节转十六进制
     *
     * @param b
     *            字节
     * @return 十六进制
     */
    public static String byteToHex(byte b) {
        int r = b & 0xFF;
        String hexResult = Integer.toHexString(r);

        StringBuilder sb = new StringBuilder();
        if (hexResult.length() < 2) {
            sb.append(0); // 前补0
        }
        sb.append(hexResult);
        return sb.toString();
    }

    /**
     * 字节数组转十六进制
     *
     * @param bytes
     *            字节数组
     * @return 十六进制
     */
    public static String bytesToHex(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return null;
        }

        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            int r = bytes[i] & 0xFF;

            String hexResult = Integer.toHexString(r);
            if (hexResult.length() < 2) {
                sb.append(0); // 前补0
            }
            sb.append(hexResult);
        }

        return sb.toString();
    }

    /**
     * 是否包含4字节UTF-8编码的字符（先转换16进制再判断）
     *
     * @param s
     *            字符串
     * @return 是否包含4字节UTF-8编码的字符
     */
    public static boolean contains4BytesChar(String s) {
        if (s == null || s.trim().length() == 0) {
            return false;
        }

        String hex = bytesToHex(s.getBytes());

        String firstChar = null;
        while (hex != null && hex.length() > 1) {
            firstChar = hex.substring(0, 1);
            if ("f".equals(firstChar)) {
                return true;
            }

            if (hexMap.get(firstChar) == null) {
                return false;
            }

            hex = hex.substring(hexMap.get(firstChar), hex.length());
        }

        return false;
    }

    /**
     * 是否包含4字节UTF-8编码的字符
     *
     * @param s
     *            字符串
     * @return 是否包含4字节UTF-8编码的字符
     */
    public static boolean contains4BytesChar2(String s) {
        if (s == null || s.trim().length() == 0) {
            return false;
        }

        byte[] bytes = s.getBytes();

        if (bytes == null || bytes.length == 0) {
            return false;
        }

        int index = 0;
        byte b;
        String hex = null;
        String firstChar = null;
        int step;
        while (index <= bytes.length - 1) {
            // System.out.println("while loop, index : " + index);
            b = bytes[index];

            hex = byteToHex(b);
            if (hex == null || hex.length() < 2) {

                return false;
            }

            firstChar = hex.substring(0, 1);

            if (firstChar.equals("f")) {
                return true;
            }

            if (byteMap.get(firstChar) == null) {
                return false;
            }

            step = byteMap.get(firstChar);
            index = index + step;
        }

        return false;
    }

    /**
     * 去除4字节UTF-8编码的字符
     *
     * @param s
     *            字符串
     * @return 已去除4字节UTF-8编码的字符
     */
    public static byte[] remove4BytesUTF8Char(String s) {
        byte[] bytes = s.getBytes();
        byte[] removedBytes = new byte[bytes.length];
        int index = 0;

        String hex = null;
        String firstChar = null;
        for (int i = 0; i < bytes.length;) {
            hex = byteToHex(bytes[i]);

            if (hex == null || hex.length() < 2) {

                return null;
            }

            firstChar = hex.substring(0, 1);

            if (byteMap.get(firstChar) == null) {
                return null;
            }

            if (firstChar.equals("f")) {
                for (int j = 0; j < byteMap.get(firstChar); j++) {
                    i++;
                }
                continue;
            }

            for (int j = 0; j < byteMap.get(firstChar); j++) {
                removedBytes[index++] = bytes[i++];
            }
        }

        return Arrays.copyOfRange(removedBytes, 0, index);
    }

    /**
     * 字符串转Unicode码
     *
     * @param str
     *            待编码字符
     * @return
     */
    public static String toUnicode(String str) {
        if (StringUtils.isEmpty(str)) {
            return null;
        }
        char[] chars = str.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < chars.length; i++) {
            sb.append(Integer.toString(chars[i], 16));
        }
        return sb.toString();
    }
    public static String trimString(String str){
        if(null != str && !"".equals(str)){
            return str.trim();
        }else{
            return "";
        }
    }
    public static String trimNullString(String str){
        if(null != str && !"".equals(str) && !"null".equals(str)){
            return str.trim();
        }else{
            return "";
        }
    }
    /**
     * 将jquery ajax 中文字符�?解码
     * @param str �?��解码的字符串
     * @return
     */
    public static String decodeString(String str){
        if(str==null || str.equals("")){
            return "";
        }
        str = str.trim();
        try {
            str = java.net.URLDecoder.decode(java.net.URLDecoder.decode(str, "UTF-8"), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return str;
    }
    /**
     * 将jquery ajax 中文字符�?解码
     * @param str �?��解码的字符串
     * @return
     */
    public static Object decodeString(Object str){
        if(str==null || str.equals("")){
            return "";
        }
        str = str.toString().trim();
        try {
            str = java.net.URLDecoder.decode(java.net.URLDecoder.decode(str.toString(), "UTF-8"), "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return str;
    }
    /**
     * 按长度在字符右边补齐空格
     * @param str
     * @param len
     * @return
     */
    public static String toChar(String str,int len){
        StringBuffer sb=new StringBuffer(str);
        len=len-str.length();
        for (int i = 0; i < len; i++) {
            sb.append(" ");
        }
        return sb.toString();
    }

    public static String trimString(Object obj){
        if (obj==null){
            return "";
        }
        String result =String.valueOf(obj);
        return result ;
    }

    public static String toSort(String source){
        if(null != source && !"".equals(source)){
            StringBuffer sort = new StringBuffer();
            char[] c = source.toCharArray();
            Arrays.sort(c);//对数组进行排�?
            for (int i = 0; i < c.length; i++) {
                sort.append(String.valueOf(c[i]));
            }
            return sort.toString();//返回数组。注：char数组相当于String类型} 完成后直接调用该方法就好了：
        }else{
            return "";
        }
    }

    /**
     * double类型取到小数点后两位
     * @param doubleValue
     * @return
     */
    public static String doubleRtTwo(double doubleValue){
        try {
            if(Double.isNaN(doubleValue)){
                return "0.0";
            }
            //科学计数法转换成普�?算法
            return String.format("%.2f", doubleValue);
        } catch (RuntimeException e) {
            e.printStackTrace();
            return "0.0";
        }
    }
    /**
     * double类型取到小数点后两位
     * @param doubleValue
     * @return
     */
    public static double double2Two(double doubleValue){
        try {
            if(Double.isNaN(doubleValue)){
                return 0.0;
            }
            //科学计数法转换成普�?算法
            return Double.parseDouble(String.format("%.2f", doubleValue));
        } catch (RuntimeException e) {
            return 0.0;
        }
    }

    /**
     * 判断字符串是否不为空
     */
    public static boolean isNotEmpty(String str) {
        Integer id = null;
        isEmpty(id);
        return !isEmpty(str);
    }
    public static boolean isNotEmpty(Object obj){
        if(obj == null){
            return false;
        }
        if("".equals(obj.toString().trim()) || "null".equals(obj.toString().trim())){
            return false;
        }
        return true;
    }
    public static boolean isEmpty(Object obj){
        if(obj == null || "".equals(obj.toString().trim()) || "null".equals(obj.toString().trim())){
            return true;
        }
        return false;
    }
    public static List<String> parseList(String code){
        String[] arr = code.split(",");
        List<String> list = new ArrayList<String>(arr.length);
        for(String _code:arr){
            list.add(_code);
        }
        return list;
    }

    /**
     * Double类别数据四舍五入转成2位小�?
     * 同时去除科学计数法的影响
     * @param val 数�?, type 类型  0(89123456.79)  1(89,123,456.79)
     * @return 格式化后数�?
     * */
    public static String doubleFixed(double val , int type){
        String returnValue = "";
        if(type == 1){
            NumberFormat nf = NumberFormat.getNumberInstance();
            nf.setMaximumFractionDigits(2);
            returnValue =  nf.format(val);
        }else{
            returnValue = String.format("%.2f", val);
        }
        return returnValue;
    }

    /**
     * 批量增加数据 获取code
     * @param intcode
     * @return
     */
    public static String getTwoCode(int intcode){
        if(intcode < 10){
            return "00"+intcode;
        }else if(intcode >= 10 && intcode < 100){
            return "0"+intcode;
        }else {
            return ""+intcode;
        }
    }

    /**
     * 批量增加数据 获取code
     * @param intcode
     * @return
     */
    public static String getThreeCode(int intcode){
        if(intcode < 10){
            return "000"+intcode;
        }else if(intcode >= 10 && intcode < 100){
            return "00"+intcode;
        }else if(intcode >= 100 && intcode < 1000){
            return "0"+intcode;
        }else {
            return ""+intcode;
        }
    }

    public static void main(String[] args) {
        int n8 = getRamdomNum8Bits();
        System.out.println(n8);

        System.out.println(hasEmoji("a1好😀Q1123"));
        System.out.println(hasEmoji("a1好"));
        System.out.println(new String(remove4BytesUTF8Char("a1好😀Q1123")));

        System.out.println(toUnicode("王凯"));
        System.out.println(toUnicode("123"));

        System.out.println(genRandomStr(18));

        System.out.println(StringUtils.getSimpleUUID().toUpperCase());
    }

}
